/**
 * 系统注册表列表
 * 
 * @param {}
 *            tabid
 */
function tableList(tabid) {
	var tableStore = new Ext.data.Store({
				proxy : new Ext.data.ScriptTagProxy({
							url : context + '/system/table.do?method=files'
						}), // 数据源
				reader : new Ext.data.ArrayReader({}, [ // 如何解析
						{
									name : 'fileName'
								}, {
									name : 'fileDesc'
								}])

			});

	var tablesCombobox = new Ext.form.ComboBox({
				id : 'tablesCombobox',
				name : 'tablesCombobox',
				xtype : 'combo',
				selectOnFocus : true,
				emptyText : '请选择数据表注册文件...',
				forceSelection : true,
				triggerAction : 'all',
				valueField : 'fileName', // 提交表单时，下拉框的值
				displayField : 'fileDesc', // 显示在页面上下拉框的值
				editable : false,
				width : 300,
				store : tableStore,
				listeners : {
					select : function(combo, record, index) {
						// alert(record.data.id);
						// alert(record.data.name);
						/* 设置combo选择项真正对应的值 */
						// alert(record.data.wbtypeid);
						var fileName = record.data.fileName;

						if (fileName.toLowerCase().indexOf('system_') > -1) {
							Ext.getCmp('addtable').disable();
							Ext.getCmp('uploadtable').disable();
						} else {
							Ext.getCmp('addtable').enable();
							Ext.getCmp('uploadtable').enable();
						}

						Ext.getCmp('deltable').disable();

						tableListStore.proxy = new Ext.data.ScriptTagProxy({
									url : context
											+ '/system/table.do?method=list&file='
											+ fileName
								});
						tableListStore.load();

					}
				}
			});

	var tableListStore = new Ext.data.JsonStore({
				idProperty : 'id',
				remoteSort : false,
				totalProperty : 'totalCount',
				root : 'tableList',
				fields : ['name', 'fname', 'memo', 'file', 'ds', 'type'],

				// load using script tags for cross domain, if the data in on
				// the same domain as
				// this page, an HttpProxy would be better
				proxy : new Ext.data.ScriptTagProxy({
							url : context + '/system/table.do?method=list'
						})
			});

	var tableListGrid = new Ext.grid.GridPanel({
		id : tabid,
		store : tableListStore,
		closable : true,
		columns : [{
					header : '表名称',
					width : 150,
					sortable : true,
					dataIndex : 'name',
					renderer : renderTableName
				}, {
					header : '表说明',
					width : 150,
					sortable : true,
					dataIndex : 'memo'
				}, {
					header : '所属文件',
					width : 150,
					sortable : false,
					dataIndex : 'file'
				}, {
					header : '数据源',
					width : 150,
					sortable : false,
					dataIndex : 'ds'
				}, {
					header : '类型',
					width : 150,
					sortable : false,
					dataIndex : 'type',
					renderer : function(value, cellmeta, record, rowIndex,
							columnIndex, store) {
						if (value == -2) {
							return '备份表';
						} else if (value == -1) {
							return '系统表';
						} else if (value > -1) {
							return '应用表'
						}

						return value;
					}
				}],
		stripeRows : true,
		autoExpandColumn : 'name',
		title : '数据表列表',
		border : false,
		viewConfig : {
			forceFit : true
		},
		// config options for stateful behavior
		stateful : true,
		stateId : 'grid',
		loadMask : {
			msg : "数据加载中，请稍等..."
		},
		tbar : new Ext.Toolbar({
			autoWidth : true,
			autoShow : true,
			items : ['表注册文件', tablesCombobox, '-', {
						id : 'addtable',
						text : '新增数据表',
						tooltip : '新增数据表注册信息',
						disabled : true,
						iconCls : 'addtable',
						handler : function() {
							edittable();
						}
					}, {
						id : 'uploadtable',
						text : '上传数据表',
						tooltip : '批量上传数据表注册信息',
						disabled : true,
						iconCls : 'uploadtable',
						handler : function() {
							var form = new Ext.FormPanel({
										frame : true,
										border : false,
										margins : '1 1 1 1',
										labelAlign : 'right',
										labelWidth : 100,
										height : 50,
										fileUpload : true,
										waitMsgTarget : true,
										defaults : {
											width : 350
										},
										defaultType : 'textfield',

										items : [{
													name : 'file1',
													fieldLabel : '数据表注册文件',
													inputType : 'file',
													xtype : 'textfield',
													allowBlank : false
												}]
									});

							var win = new Ext.Window({
								title : '数据表批量上传',
								width : 500,
								layout : 'fit',
								items : [form],
								plain : true,
								modal : true,
								buttons : [{
									text : ' 提 交 ',
									handler : function() {
										if (form.getForm().isValid()) {
											Ext.MessageBox.confirm('数据表上传提示',
													'确定上传', function(btn) {
														if (btn == 'yes') {
															Ext.MessageBox
																	.wait('数据上传过程中...');

															form.getForm()
																	.submit({
																		url : context
																				+ '/system/table.do?method=upload',
																		method : 'POST',
																		params : {
																			fileName : Ext
																					.getCmp("tablesCombobox")
																					.getValue()
																		},
																		success : function(
																				response,
																				options) {
																			var o = Ext.util.JSON
																					.decode(response.responseText);
																			Ext.Msg
																					.alert(
																							'提示',
																							'数据表上传成功'); //
																			tableListGrid
																					.getStore()
																					.reload();
																		},
																		failure : function(
																				response,
																				options) {
																			Ext.MessageBox
																					.show(
																							{
																								title : '数据表上传失败',
																								msg : response.responseText,
																								icon : Ext.MessageBox.ERROR
																							});
																		}
																	});
														}
													});
										}
									}
								}]
							});

							win.show(this);
						}
					}, {
						id : "deltable",
						text : "删除数据表",
						disabled : true,
						tooltip : '删除数据表注册信息',
						iconCls : 'deltable',
						handler : function() {
							Ext.MessageBox
									.confirm(
											'提示',
											'为了确保数据安全性,删除数据表操作只将数据表注册信息删除,并未从数据库中真正删除数据表',
											function(btn) {
												if (btn == 'yes') {
													var tableNames = '';
													var dsNames = ''
													var selectedNodes = tableListGrid
															.getSelectionModel()
															.getSelections();
													for (var i = 0; i < selectedNodes.length; i++) {
														if (i < selectedNodes.length
																- 1) {
															tableNames += selectedNodes[i].data.name
																	+ ',';
															dsNames += selectedNodes[i].data.ds
																	+ ',';
														} else {
															tableNames += selectedNodes[i].data.name;
															dsNames += selectedNodes[i].data.ds;
														}
													}

													Ext.MessageBox
															.wait('数据表删除过程中...');

													Ext.Ajax.request({
														url : context
																+ "/system/table.do?method=delete",
														method : 'POST',
														async : false,
														params : {
															tableNames : tableNames,
															dsNames : dsNames
														},
														success : function(
																response,
																options) {
															var o = Ext.util.JSON
																	.decode(response.responseText);
															if (!o.success) {
																Ext.Msg
																		.alert(
																				'提示',
																				'删除数据表出现异常');
															} else {
																Ext.Msg
																		.alert(
																				'提示',
																				'已成功删除数据表');
																tableListGrid
																		.getStore()
																		.reload();
															}
														}
													})
												}
											});
						}
					}]
		}),
		bbar : new Ext.Toolbar([{
					iconCls : 'refresh',
					text : '刷新',
					handler : function() {
						tableListGrid.getStore().reload();
					}
				}])
	});

	tableListGrid.setIconClass('tabs');

	tableListGrid.on('rowclick', function(grid, rowIndex) {
				if (Ext.getCmp("tablesCombobox").getValue().toLowerCase()
						.indexOf('system_') == -1) {
					if (tableListGrid.getSelectionModel().hasSelection()) {
						Ext.getCmp('deltable').enable();
					} else {
						Ext.getCmp('deltable').disable();
					}
				}
			});

	tableListStore.load({
				params : {
					start : 0,
					limit : pageSize
				}
			});

	return tableListGrid;
};

function renderTableName(value, cellmeta, record, rowIndex, columnIndex, store) {
	var resultString;

	if (record.data['type'] == '-1') {
		resultString = String
				.format(
						'<b><a href="javascript:void(0);" onclick="javascript:viewtable(\'{0}\', \'{1}\', \'{2}\');">{0}</a></b>',
						value, record.data.memo, record.data.ds);
	} else {
		resultString = String
				.format(
						'<b><a href="javascript:void(0);" onclick="javascript:edittable(\'{0}\', \'{1}\', \'{2}\', \'{3}\', \'{4}\');">{0}</a></b>',
						value, record.data.fname, record.data.type,
						record.data.memo, record.data.ds);
	}

	return resultString;
};

function edittable(name, fname, type, memo, ds) {
	var tableType = getWBComboStore('table-type', '', '_tableType', '数据表类型',
			'tableType', 'tableTypeName', '', false);

	var tableForm = new Ext.FormPanel({
				labelWidth : 100, // label
				frame : false,
				region : 'north',
				bodyStyle : 'padding:5px 5px 0',
				height : 150,
				defaults : {
					width : 230
				},
				defaultType : 'textfield',

				items : [{
							fieldLabel : '数据表名称',
							name : 'tableName',
							allowBlank : false
						}, {
							fieldLabel : '数据表别名',
							name : 'fakeName'
						}, tableType, {
							fieldLabel : '数据源名',
							name : 'dataSource'
						}, {
							fieldLabel : '描述说明',
							name : 'tableDesc'
						}, {
							id : 'tableType',
							name : 'tableType',
							xtype : 'hidden'
						}, {
							id : 'tableTypeName',
							name : 'tableTypeName',
							xtype : 'hidden'
						}, {
							id : 'otableName',
							name : 'otableName',
							xtype : 'hidden'
						}, {
							id : 'ods',
							name : 'ods',
							xtype : 'hidden'
						}]
			});

	var columnListStore;

	var url = context + '/system/table.do?method=register';

	if (name != null) {
		var typeName = '其他';

		if (type == -2) {
			typeName = '备份表';
		} else if (type == -1) {
			typeName = '系统表';
		} else if (type == 0) {
			typeName = '应用表';
		}

		tableForm.getForm().load({
					url : context + '/system/result4form.jsp',
					params : {
						tableName : name,
						fakeName : fname,
						dataSource : ds,
						tableType : type,
						tableTypeName : typeName,
						_tableType : typeName,
						tableDesc : memo,
						otableName : name,
						ods : ds
					},
					success : function(form, action) {
						Ext.getCmp('registeTable').setDisabled(false);
					},
					failure : function(form, action) {
						Ext.Msg.alert('初始化表信息失败');
					}
				});

		columnListStore = new Ext.data.JsonStore({
					idProperty : 'id',
					remoteSort : false,
					totalProperty : 'totalCount',
					root : 'columnList',
					fields : ['name', 'fname', 'memo', 'type', 'typeName',
							'notnull', 'length', 'key', 'scale',
							'foreignTable', 'foreignColumn'],

					// load using script tags for cross domain, if the data in
					// on
					// the same domain as
					// this page, an HttpProxy would be better
					proxy : new Ext.data.ScriptTagProxy({
								url : context
										+ '/system/table/columnlist.jsp?tname='
										+ name + "&ds=" + ds
							})
				});

		columnListStore.load({
					params : {
						start : 0,
						limit : 20
					}
				});

		url = context + '/system/table.do?method=reregister';
	} else {
		columnListStore = new Ext.data.Store({
					reader : new Ext.data.ArrayReader({}, ['name', 'fname',
									'memo', 'type', 'notnull', 'typeName',
									'length', 'scale', 'key', 'foreignTable',
									'foreignColumn'])
				});
	}

	var columnListGrid = new Ext.grid.GridPanel({
		id : 'columnListGrid',
		store : columnListStore,
		columns : [{
			header : '字段名称',
			width : 100,
			sortable : true,
			dataIndex : 'name',
			renderer : function(value, cellmeta, record, rowIndex, columnIndex,
					store) {
				var resultString = String
						.format(
								'<b><a href="javascript:void(0);" title="编辑" onclick="javascript:editcolumn(\'{0}\', \'{1}\', \'{2}\''
										+ ',\'{3}\', \'{4}\', \'{5}\',\'{6}\', \'{7}\', \'{8}\''
										+ ', \'{9}\', \'{10}\', \'{11}\', \'{12}\', \'{13}\');">'
										+ value + '</a></b>', value,
								record.data.fname, record.data.memo,
								record.data.type, record.data.notnull,
								record.data.notnullname, record.data.typeName,
								record.data.length, record.data.key,
								record.data.keyname, record.data.foreignTable,
								record.data.foreignColumn, rowIndex,
								record.data.scale);

				return resultString;

			}
		}, {
			header : '表单域名称',
			width : 100,
			sortable : true,
			dataIndex : 'fname'
		}, {
			header : '字段说明',
			width : 100,
			sortable : true,
			dataIndex : 'memo'
		}, {
			header : '非空',
			width : 100,
			sortable : true,
			dataIndex : 'notnull',
			renderer : function(value) {
				if (value == '0') {
					return '是'
				}

				return '否'
			}
		}, {
			header : '类型',
			width : 100,
			sortable : true,
			dataIndex : 'typeName'
		}, {
			header : '长度',
			width : 100,
			sortable : true,
			dataIndex : 'length'
		}, {
			header : '小数位',
			width : 100,
			sortable : true,
			dataIndex : 'scale'
		}, {
			header : '主键',
			width : 100,
			sortable : true,
			dataIndex : 'key',
			renderer : function(value) {
				if (value == '0') {
					return '是'
				}

				return '否'
			}
		}, {
			header : '外键表',
			width : 100,
			sortable : true,
			dataIndex : 'foreignTable'
		}, {
			header : '外键表主键',
			width : 100,
			sortable : true,
			dataIndex : 'foreignColumn'
		}],
		stripeRows : true,
		autoExpandColumn : 'name',
		border : false,
		viewConfig : {
			forceFit : true
		},
		region : 'center',
		// config options for stateful
		// behavior
		stateful : true,
		stateId : 'grid',
		loadMask : {
			msg : "数据加载中，请稍等..."
		},
		clicksToEdit : 1,
		tbar : new Ext.Toolbar({
			autoWidth : true,
			autoShow : true,
			items : [{
						text : '新增字段',
						tooltip : '增加表字段信息',
						iconCls : 'addcolumn',
						handler : function() {
							editcolumn();
						}
					}, {
						text : '删除字段',
						id : 'removeColumn',
						tooltip : '删除已定义的字段',
						iconCls : 'removecolumn',
						disabled : true,
						handler : function() {
							Ext.MessageBox.confirm('提示', '确定删除？',
									function(btn) {
										if (btn == 'yes') {
											Ext.getCmp('removeColumn')
													.disable();

											var selectedNodes = Ext
													.getCmp('columnListGrid')
													.getSelectionModel()
													.getSelections();
											for (var i = 0; i < selectedNodes.length; i++) {
												Ext
														.getCmp('columnListGrid')
														.getStore()
														.remove(selectedNodes[i]);
											}

											if (Ext.getCmp('columnListGrid')
													.getStore().getCount() == 0) {
												Ext.getCmp('registeTable')
														.setDisabled(true);
											}
										}
									});
						}
					}]
		})
	});

	columnListGrid.on('rowclick', function(grid, rowIndex) {
				if (columnListGrid.getSelectionModel().hasSelection()) {
					Ext.getCmp('removeColumn').enable();
				} else {
					Ext.getCmp('removeColumn').disable();
				}
			});

	var win = new Ext.Window({
		title : '数据表注册',
		renderTo : Ext.getBody(),
		layout : 'border',
		closable : true,
		resizable : false,
		// maximizable : true,
		width : 700,
		height : 500,
		border : false,
		plain : true,
		modal : true,
		items : [tableForm, columnListGrid],
		buttons : [{
			text : ' 确 定 ',
			id : 'registeTable',
			disabled : true,
			handler : function() {
				if (tableForm.getForm().isValid()) {
					Ext.MessageBox.confirm('提示', '确定提交', function(btn) {
								if (btn == 'yes') {
									var params = {};
									params.fileName = Ext
											.getCmp("tablesCombobox")
											.getValue();
									params.tableName = tableForm.getForm()
											.findField('tableName').getValue();
									params.fakeName = tableForm.getForm()
											.findField('fakeName').getValue();

									var countP = '';

									for (var i = 0; i < columnListGrid
											.getStore().getCount(); i++) {
										var name = columnListGrid.getStore()
												.getAt(i).get('name');
										var fname = columnListGrid.getStore()
												.getAt(i).get('fname');
										var memo = columnListGrid.getStore()
												.getAt(i).get('memo');
										var type = columnListGrid.getStore()
												.getAt(i).get('type');
										var length = columnListGrid.getStore()
												.getAt(i).get('length');
										var scale = columnListGrid.getStore()
												.getAt(i).get('scale');
										var key = columnListGrid.getStore()
												.getAt(i).get('key');
										var notnull = columnListGrid.getStore()
												.getAt(i).get('notnull');
										var foreignTable = columnListGrid
												.getStore().getAt(i)
												.get('foreignTable');
										var foreignColumn = columnListGrid
												.getStore().getAt(i)
												.get('foreignColumn');

										params['name_' + i] = name;
										params['fname_' + i] = fname;
										params['memo_' + i] = memo;
										params['type_' + i] = type;
										params['length_' + i] = length;
										params['scale_' + i] = scale;
										params['key_' + i] = key;
										params['notnull_' + i] = notnull;
										params['foreignTable_' + i] = foreignTable;
										params['foreignColumn_' + i] = foreignColumn;

										countP += i + ',';
									}

									params.countP = countP;

									Ext.MessageBox.wait('表注册过程中...');

									Ext.getCmp('registeTable')
											.setDisabled(true);

									tableForm.getForm().submit({
										url : url,
										method : 'POST',
										params : params,
										success : function(form, action) {
											Ext.Msg.alert('提示', '表注册成功！'); //
											win.close();
											win = null;

											Ext.getCmp('tab_tablelist')
													.getStore().reload();
										},
										failure : function(form, action) {
											Ext.MessageBox.show({
														title : '表注册失败',
														msg : action.result.errMsg,
														icon : Ext.MessageBox.ERROR
													});

											Ext.getCmp('registeTable')
													.setDisabled(false);
										}
									});
								}
							})
				}
			}
		}, {
			text : ' 取 消 ',
			handler : function() {
				win.close();
				win = null;
			}
		}]
	});

	win.show(this);
}

function viewtable(id, name, ds) {
	var columnListStore = new Ext.data.JsonStore({
				idProperty : 'id',
				remoteSort : false,
				totalProperty : 'totalCount',
				root : 'columnList',
				fields : ['name', 'fname', 'memo', 'type', 'typeName',
						'length', 'scale', 'key', 'notnull', 'foreignTable',
						'foreignColumn'],

				// load using script tags for cross domain, if the data in on
				// the same domain as
				// this page, an HttpProxy would be better
				proxy : new Ext.data.ScriptTagProxy({
							url : context
									+ '/system/table/columnlist.jsp?tname='
									+ id + "&ds=" + ds
						})
			});

	var columnListGrid = new Ext.grid.GridPanel({
				id : 'columnListGrid',
				store : columnListStore,
				columns : [{
							header : '字段名称',
							width : 100,
							sortable : true,
							dataIndex : 'name'
						}, {
							header : '表单域名称',
							width : 100,
							sortable : true,
							dataIndex : 'fname'
						}, {
							header : '字段说明',
							width : 100,
							sortable : true,
							dataIndex : 'memo'
						}, {
							header : '非空',
							width : 100,
							sortable : true,
							dataIndex : 'notnull',
							renderer : function(value, cellmeta, record,
									rowIndex, columnIndex, store) {
								if (value) {
									return '是';
								}

								return '否';
							}
						}, {
							header : '类型',
							width : 100,
							sortable : true,
							dataIndex : 'typeName'
						}, {
							header : '长度',
							width : 100,
							sortable : true,
							dataIndex : 'length'
						}, {
							header : '小数位',
							width : 100,
							sortable : true,
							dataIndex : 'scale'
						}, {
							header : '主键',
							width : 100,
							sortable : true,
							dataIndex : 'key',
							renderer : function(value, cellmeta, record,
									rowIndex, columnIndex, store) {
								if (value) {
									return '是';
								}

								return '否';
							}
						}, {
							header : '外键表',
							width : 100,
							sortable : true,
							dataIndex : 'foreignTable'
						}, {
							header : '外键字段',
							width : 100,
							sortable : true,
							dataIndex : 'foreignColumn'
						}],
				stripeRows : true,
				autoExpandColumn : 'name',
				height : 300,
				width : 270,
				border : false,
				viewConfig : {
					forceFit : true
				},
				// config options for stateful behavior
				stateful : true,
				stateId : 'grid',
				loadMask : {
					msg : "数据加载中，请稍等..."
				}
			});

	columnListStore.load({
				params : {
					start : 0,
					limit : pageSize
				}
			});

	var win = new Ext.Window({
				title : '数据表&nbsp;{' + name + '}',
				renderTo : Ext.getBody(),
				layout : 'fit',
				closable : true,
				resizable : false,
				// maximizable : true,
				width : 750,
				height : 450,
				border : false,
				plain : true,
				modal : true,
				items : [columnListGrid]
			});

	win.show(this);
}

/**
 * 字段项定义
 * 
 * @param {}
 *            name
 * @param {}
 *            fname
 * @param {}
 *            memo
 * @param {}
 *            type
 * @param {}
 *            notnull
 * @param {}
 *            notnullname
 * @param {}
 *            typename
 * @param {}
 *            length
 * @param {}
 *            key
 * @param {}
 *            keyname
 * @param {}
 *            foreignTable
 * @param {}
 *            foreignColumn
 */
function editcolumn(name, fname, memo, type, notnull, notnullname, typename,
		length, key, keyname, foreignTable, foreignColumn, rowIndex, scale) {
	var columnType = getWBComboStore('column-type', '', '_columnType', '字段类型',
			'columnType', 'columnTypeName', '', false);

	var columnForm = new Ext.FormPanel({
		labelWidth : 75, // label
		// settings
		// here cascade
		// unless overridden
		frame : false,
		bodyStyle : 'padding:5px 5px 0',
		width : 350,
		defaults : {
			width : 230
		},
		defaultType : 'textfield',

		items : [{
					fieldLabel : '字段名称',
					name : 'columnName',
					allowBlank : false
				}, {
					fieldLabel : '表单域名称',
					name : 'formName'
				}, {
					fieldLabel : '字段说明',
					name : 'columnDesc'
				}, new Ext.form.RadioGroup({
							fieldLabel : '非空',
							// //RadioGroup.fieldLabel
							// 标签与
							// Radio.boxLabel 标签区别
							items : [new Ext.form.Radio({ // 以上相同
								id : 'notnull0',
								name : 'notnullChk',
								boxLabel : '是',
								inputValue : '0',
								listeners : {
									check : function(checkbox, checked) {
										if (checked) {
											columnForm.getForm()
													.findField('notnull')
													.setValue('0');
										}
									}
								}
							}), new Ext.form.Radio({ // 三个必须项
								id : 'notnull1',
								name : 'notnullChk',
								checked : true,
								// //
								// 设置当前为选中状态,仅且一个为选中.
								boxLabel : '否', // Radio标签
								inputValue : '-1', // 提交时传送的参数值
								listeners : {
									check : function(checkbox, checked) { // 选中时,调用的事件
										if (checked) {
											columnForm.getForm()
													.findField('notnull')
													.setValue('-1');
										}
									}
								}
							})]
						}), new Ext.form.RadioGroup({
							fieldLabel : '主键',
							// //RadioGroup.fieldLabel
							// 标签与
							// Radio.boxLabel 标签区别
							items : [new Ext.form.Radio({ // 以上相同
								id : 'primaryKey0',
								name : 'primaryChk',
								boxLabel : '是',
								inputValue : '0',
								listeners : {
									check : function(checkbox, checked) {
										if (checked) {
											columnForm.getForm()
													.findField('primaryKey')
													.setValue('0');
										}
									}
								}
							}), new Ext.form.Radio({ // 三个必须项
								id : 'primaryKey1',
								name : 'primaryChk',
								checked : true,
								// //
								// 设置当前为选中状态,仅且一个为选中.
								boxLabel : '否', // Radio标签
								inputValue : '-1', // 提交时传送的参数值
								listeners : {
									check : function(checkbox, checked) { // 选中时,调用的事件
										if (checked) {
											columnForm.getForm()
													.findField('primaryKey')
													.setValue('-1');
										}
									}
								}
							})]
						}), columnType, {
					fieldLabel : '字段长度',
					name : 'columnSize',
					xtype : 'numberfield',
					allowBlank : false
				}, {
					fieldLabel : '字段小数位',
					name : 'columnScale',
					xtype : 'numberfield'
				}, {
					id : 'columnType',
					name : 'columnType',
					xtype : 'hidden'
				}, {
					id : 'columnTypeName',
					name : 'columnTypeName',
					xtype : 'hidden'
				}, {
					id : 'primaryKey',
					name : 'primaryKey',
					xtype : 'hidden',
					value : '-1'
				}, {
					id : 'notnull',
					name : 'notnull',
					xtype : 'hidden',
					value : '-1'
				}, {
					fieldLabel : '外键表',
					name : 'foreignTable'
				}, {
					fieldLabel : '外键表主键',
					name : 'foreignColumn'
				}],

		buttons : [{
			text : ' 确 定 ',
			handler : function() {
				if (columnForm.getForm().isValid()) {
					/* 存在重复的字段定义 */
					if (hasColumn(Ext.getCmp('columnListGrid'), trim(columnForm
									.getForm().findField('columnName')
									.getValue()), rowIndex)) {
						return false;
					}

					if (rowIndex == null) {
						var Plant = Ext.getCmp('columnListGrid').getStore().recordType;
						var p = new Plant({
									name : columnForm.getForm()
											.findField('columnName').getValue(),
									fname : columnForm.getForm()
											.findField('formName').getValue(),
									memo : columnForm.getForm()
											.findField('columnDesc').getValue(),
									notnull : columnForm.getForm()
											.findField('notnull').getValue(),
									type : columnForm.getForm()
											.findField('columnType').getValue(),
									typeName : columnForm.getForm()
											.findField('columnTypeName')
											.getValue(),
									length : columnForm.getForm()
											.findField('columnSize').getValue(),
									scale : columnForm.getForm()
											.findField('columnScale')
											.getValue(),
									key : columnForm.getForm()
											.findField('primaryKey').getValue(),
									foreignTable : columnForm.getForm()
											.findField('foreignTable')
											.getValue(),
									foreignColumn : columnForm.getForm()
											.findField('foreignColumn')
											.getValue()
								});

						Ext.getCmp('columnListGrid').getStore().insert(
								Ext.getCmp('columnListGrid').getStore()
										.getCount(), p);
					} else {
						var record = Ext.getCmp('columnListGrid').getStore()
								.getAt(rowIndex);
						record.set('name', columnForm.getForm()
										.findField('columnName').getValue());
						record.set('fname', columnForm.getForm()
										.findField('formName').getValue());
						record.set('memo', columnForm.getForm()
										.findField('columnDesc').getValue());
						record.set('notnull', columnForm.getForm()
										.findField('notnull').getValue());
						record.set('type', columnForm.getForm()
										.findField('columnType').getValue());
						record
								.set('typeName', columnForm.getForm()
												.findField('columnTypeName')
												.getValue());
						record.set('length', columnForm.getForm()
										.findField('columnSize').getValue());
						record.set('scale', columnForm.getForm()
										.findField('columnScale').getValue());
						record.set('key', columnForm.getForm()
										.findField('primaryKey').getValue());
						record.set('foreignTable', columnForm.getForm()
										.findField('foreignTable').getValue());
						record.set('foreignColumn', columnForm.getForm()
										.findField('foreignColumn').getValue());
					}

					win.close();
					win = null;

					if (Ext.getCmp('registeTable').disabled) {
						Ext.getCmp('registeTable').enable();
					}
				}
			}
		}, {
			text : ' 取 消 ',
			handler : function() {
				win.close();
				win = null;
			}
		}]
	});

	if (name != null) {
		columnForm.getForm().load({
					url : context + '/system/result4form.jsp',
					params : {
						columnName : name,
						formName : fname,
						columnDesc : memo,
						columnType : type,
						columnTypeName : typename,
						_columnType : typename,
						notnull : notnull,
						columnSize : length,
						columnScale : scale,
						primaryKey : key,
						foreignTable : foreignTable,
						foreignColumn : foreignColumn
					},
					success : function(form, action) {
						if (action.result.data['notnull'] == '0') {
							Ext.get("notnull0").dom.checked = true;
						} else {
							Ext.get("notnull1").dom.checked = true;
						}
						if (action.result.data['primaryKey'] == '0') {
							Ext.get("primaryKey0").dom.checked = true;
						} else {
							Ext.get("primaryKey1").dom.checked = true;
						}
					},
					failure : function(form, action) {
						Ext.Msg.alert('初始化字段信息失败');
					}
				});
	}

	var win = new Ext.Window({
				title : '字段定义',
				renderTo : Ext.getBody(),
				layout : 'fit',
				closable : true,
				resizable : false,
				// maximizable : true,
				width : 400,
				height : 450,
				border : false,
				plain : true,
				modal : true,
				items : [columnForm]
			});

	win.show(this);
}

/**
 * 存在重复的字段定义
 * 
 * @param {}
 *            grid 字段列表
 * @param {}
 *            columnName 字段名称
 * @param {}
 *            exceptIndex 例外index
 * @return {}
 */
function hasColumn(grid, columnName, exceptIndex) {
	var rnt = false;
	for (var i = 0; i < grid.getStore().getCount(); i++) {
		if ((exceptIndex == null && grid.getStore().getAt(i).get('name') == columnName)
				|| ((exceptIndex != null && i != exceptIndex) && grid
						.getStore().getAt(i).get('name') == columnName)) {
			rnt = true;
			Ext.MessageBox.alert('提示', '重复的字段[' + columnName + ']定义');
			break;
		}
	}

	return rnt;
}